package org.aplombh.java.awcing.basic.graph.dag.topo;

import java.util.Arrays;
import java.util.Scanner;

/**
 * 给定一个 n 个点 m 条边的有向图，点的编号是 1 到 n，图中可能存在重边和自环。
 * <p>
 * 请输出任意一个该有向图的拓扑序列，如果拓扑序列不存在，则输出 −1。
 * <p>
 * 若一个由图中所有点构成的序列 A 满足：对于图中的每条边 (x,y)，x 在 A 中都出现在 y 之前，则称 A 是该图的一个拓扑序列。
 * <p>
 * 输入格式
 * 第一行包含两个整数 n 和 m。
 * <p>
 * 接下来 m 行，每行包含两个整数 x 和 y，表示存在一条从点 x 到点 y 的有向边 (x,y)。
 * <p>
 * 输出格式
 * 共一行，如果存在拓扑序列，则输出任意一个合法的拓扑序列即可。
 * <p>
 * 否则输出 −1。
 * <p>
 * 数据范围
 * 1≤n,m≤105
 * 输入样例：
 * 3 3
 * 1 2
 * 2 3
 * 1 3
 * 输出样例：
 * 1 2 3
 */
public class TopologicalSorting_848 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int n = scanner.nextInt();
        int m = scanner.nextInt();
        TopologicalSorting topologicalSorting = new TopologicalSorting(n);
        for (int i = 0; i < m; i++) {
            int a = scanner.nextInt();
            int b = scanner.nextInt();
            topologicalSorting.add(a, b);
        }
        if (topologicalSorting.topSort())
            System.out.println(topologicalSorting);
        else
            System.out.println("-1");
    }
}

class TopologicalSorting {
    public final static int N = 100010;
    int[] h = new int[N];
    int[] e = new int[N];
    int[] ne = new int[N];
    int idx, head, tail, n;
    int[] d = new int[N]; // 存储入度数 Store the in-degree
    int[] q = new int[N];

    /**
     * 加入从a到b的边,将b加入a点的邻接表中 Add the edge from a to b, add b to the adjacency list at point a
     *
     * @param a a节点 a node
     * @param b b节点 b node
     */
    void add(int a, int b) {
        // 将b存入e中  Store b in e
        e[idx] = b;
        // 将b点的ne指针指向a节点的邻接表的头节点 Set the ne pointer of point B to the head node of the adjacency list of node a
        ne[idx] = h[a];
        // 将a的邻接表的头节点指向b节点 Point the head node of a's adjacency list to b
        h[a] = idx++;
        // 将入度+1
        d[b]++;
    }

    TopologicalSorting(int n) {
        this.n = n;
        init();
    }

    void init() {
        Arrays.fill(h, -1);
        h[0] = 0;
        // 队列的队头
        head = 0;
        // 队列的队尾
        tail = 0;
    }

    public boolean topSort() {
        // 将入度为0的点加入队列
        for (int i = 1; i <= n; i++) {
            if (d[i] == 0) {
                q[++tail] = i;
            }
        }
        while (head <= tail) {
            // 头节点出列 The head node goes out
            int t = q[head++];
            // 遍历头节点的邻接表 Traverses the adjacency list of the head node
            for (int i = h[t]; i != -1; i = ne[i]) {
                int j = e[i];
                // 入度-1
                d[j]--;
                // 如果入度为0添加进出队队列
                if (d[j] == 0) {
                    q[++tail] = j;
                }
            }
        }
        // 返回最后一个元素
        return tail == n;
    }

    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 1; i <= n; i++) {
            stringBuilder.append(q[i]).append(" ");
        }
        return stringBuilder.toString();
    }
}